﻿#include<iostream>
using namespace std;

//继承概念练习


//class Student
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{
//		// ...
//	}
//	// 学习
//	void study()
//	{
//		// ...
//	}
//protected:
//	string _name = "peter"; // 姓名
//	string _address; // 地址
//	string _tel; // 电话
//	int _age = 18; // 年龄
//	int _stuid; // 学号
//};
//class Teacher
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity(){
//		// ...
//	}
//	// 授课
//	void teaching(){
//		//...
//	}
//protected:
//	string _name = "张三"; // 姓名
//	int _age = 18; // 年龄
//	string _address; // 地址
//	string _tel; // 电话
//	string _title; // 职称
//};
//这样写很多代码重复了，很冗余


//class Preson {
//public:
//	void identity() {
//		cout << "identity: " << _id << endl;
//	}
//
//protected:
//	string _name = "peter"; // 姓名
//	string _address; // 地址
//	string _tel; // 电话
//	string _id;//身份
//	int _age = 18; // 年龄 
//private:
//};
//
//class Student : public Preson {
//public:
//	void study(){}
//protected:
//	int _stuid;//学号
//};
//
//class Teacher : public Preson {
//public:
//	void teach() {}
//protected:
//	string _title;//职称
//};

//int main()
//{
//	Student s;
//	Teacher t;
//
//	return 0;
//}



//class A {
//public:
//	int _b = 0;
//private:
//	int _a = 1;
//};
//
//class a : public A {
//public:
//	void Test01() {
//	}
//protected:
//	int* _ptr = nullptr;
//};
//
//class a1 : A {
//protected:
//	int _s = 0;
//};
//
//int main() {
//	a1 aa1;
//	aa1._a;
//	aa1._b;
//	return 0;
//}



//#include<list>
//#include<deque>
//#include<vector>
//template<class T>
//class stack : public  std::vector<T>{
//public:
//	void push(const T& val) {
//		std::vector<T>::push_back(val);
//	}
//
//	void pop() {
//		std::vector<T>::pop_back();
//	}
//
//	size_t size() const{
//		return std::vector<T>::size();
//	}
//
//	bool empty() const {
//		return std::vector<T>::empty();
//	}
//
//	T& top() {
//		return std::vector<T>::back();
//	}
//
//	const T& top() const{
//		return std::vector<T>::back();
//	}
//
//protected:
//};
//
//int main() {
//	stack<int> st1;
//	st1.push(1);
//	st1.push(2);
//	st1.push(3);
//
//	while (!st1.empty()) {
//		cout << st1.top() << " ";
//		st1.pop();
//	}
//	cout << endl;
//
//	return 0;
//}


//确认模板类定义对象的时候先实例化构造函数
//template<class T>
//class A {
//private:
//	A()
//	:_a(0),_b(0)
//	{}
//	T _a;
//	T _b;
//};
//
//int main() {
//	A<int> a;
//	return 0;
//}



//class Person
//{
//protected:
//	string _name; // 姓名
//	string _sex; // 性别
//	int _age; // 年龄
//};
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//int main()
//{
//	//Student sobj;
//	//// 1.派⽣类对象可以赋值给基类的指针/引⽤
//	//Person* pp = &sobj;
//	//Person& rp = sobj;
//	//// 派⽣类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的
//	//Person pobj = sobj;
//
//	////2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
//	////sobj = pobj;
//
//	//将基类的指针/引用 强制转化为派生类的指针/引用
//	Student a;
//	Student* pa = &a;
//	Person p;
//	Person* pp = &p;
//
//	pa = (Student*)pp;
//
//
//	return 0;
//}

//class A {
//public:
//	void test() {
//		cout << "class A: test()" << endl;
//	}
//protected:
//	int _a = 0;
//	int _b = 1;
//};
//
//class AA : public A {
//public:
//	void test() {
//		cout << "class AA: test()" << endl;
//	}
//
//protected:
//	int _a = 2;
//	int _b = 3;
//};
//
//int main() {
//	AA aa;
//	aa.A::test();
//	return 0;
//
//}
// 
// 
//class A {
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//
//class B : public A {
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//int main() {
//	B b;
//	b.fun(10);
//	b.fun();
//	return 0;
//};


//#include<string>
//class Person {
//public:
//
//	//Person的默认构造
//	/*Person()
//		:_name(""),
//		_gender(""),
//		_age(0)
//	{}*/
//	Person(string name, string gender, size_t age)
//		:_name(""),
//		_gender(""),
//		_age(0)
//	{}
//
//protected:
//	string _name;
//	string _gender;
//	size_t _age;
//};
//
//class Teacher : public Person {
//public:
//	Teacher()
//	{
//		Person("", "", 0); 
//	}
//protected:
//	int _id = 0;//工号
//	string _title;//身份
//};
//
//int main() {
//	Teacher t1;
//	return 0;
//}







//#include<string>
//
//class Person {
//public:
//
//	//Person的默认构造
//	Person()
//		:_name(""),
//		_gender(""),
//		_age(0)
//	{}
//	
//	Person(string name, string gender, size_t age)
//		:_name(name),
//		_gender(gender),
//		_age(0)
//	{}
//
//
//protected:
//	string _name;
//	string _gender;
//	size_t _age;
//};
//
//class Student : public Person {
//public:
//	Student()
//		:Person("zhangsan", "male", 18),
//		_pos("班长"),
//		_stuid(2301)
//	{}
//
//	Student(const Student& stu)
//		:Person(stu),
//		_pos(stu._pos),
//		_stuid(stu._stuid)
//	{}
//	
//protected:
//	string _pos;//班级职务
//	int _stuid;//学号
//};
//
//int main() {
//
//	Student stuA; 
//	Student stuB = stuA; 
//
//	return 0;
//}

//class Person{
// public:
//	Person(const char* name = "peter")
//		 : _name(name)
//	{}
//	Person(const Person& p)
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//		return *this;
//	}
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//public:
//	Student(const char* name, int num)
//		: Person(name)
//		, _num(num)
//	{
//		cout << "Student()" << endl;
//	}
//	Student(const Student& s)
//		: Person(s)
//		, _num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//	Student& operator= (const Student& s)
//	{
//		cout << "Student& operator= (const Student& s)" << endl;
//		if (this != &s){
//			// 构成隐藏，所以需要显⽰调⽤
//			Person::operator =(s);
//			_num = s._num;
//		}
//		return *this;
//	}
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _num; //学号
//};
//
//int main() {
//	Student stu("zhangsan", 10);
//	return 0;
//}

//class Base final
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//private:
//	// C++98的⽅法
//	/*Base()
//	{}*/
//};
//
//class Derive :public Base
//{
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}


//
//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	int _stuNum; // 学号
//};
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//int main()
//{
//	Person p;
//	Student s;
//	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
//	// 解决⽅案：Display也变成Student 的友元即可
//	Display(p, s);
//	return 0;
//}


//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//int Person::_count = 0;
//class Student : public Person
//{
//protected:
//	int _stuNum;
//};
//int main()
//{
//	Person p;
//	Student s;
//	// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
//	// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//	// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
//	// 说明派⽣类和基类共⽤同⼀份静态成员
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//	// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员
//	cout << Person::_count << endl;
//    cout << Student::_count << endl;
//	
//	return 0;
//	
//}

//class Student {
//protected:
//	int _stuid;
//	string _name;
//};
//
//class Teacher {
//protected:
//	int _id;
//	string _name;
//};
//
//class Assistant : public Student, public Teacher {
//protected:
//	int _num;
//};
//
//int main() {
//	Assistant assist;
//
//
//	return 0;
//}

//class Person {
//public:
//	string _name; // 姓名
//};
//class Student : virtual public Person{
//protected:
//	int _num; //学号
//};
//class Teacher : virtual public Person{
//protected:
//	int _id; // 职⼯编号
//};
//class Assistant : public Student, public Teacher{
//protected:
//	string _majorCourse; // 主修课程
//};
//int main()
//{
//	// 编译报错：error C2385: 对“_name”的访问不明确
//	Assistant a;
//	a._name = "peter";
//	// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
//	a.Student::_name = "xxx";
//	a.Teacher::_name = "yyy";
//	return 0;
//}




class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main(){
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}		
